package com.example.dict1.controller;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.example.dict1.AjaxResult;
import com.example.dict1.entity.Dict;
import com.example.dict1.service.DictService;
import com.example.dict1.vo.DictVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;


/**
 * 字典模块API
 */
@Api(tags = "系统字典表")
@Validated
@RestController
@RequestMapping("/dict")
@Slf4j
public class DictController {

    //自动注入

    @Resource
    private DictService dictService;


    /**
     * 保存 系统字典表
     * @param vO 实体类
     * @return 结果集
     */
    @PostMapping
    @ApiOperation("保存 系统字典表")
    public AjaxResult save(@Valid @RequestBody DictVO vO) {
        return AjaxResult.success(dictService.save(vO).toString());
    }

    /**
     * 根据id删除数据
     * @param id 主键ID
     * @return 结果集
     */
    @DeleteMapping("/{id}")
    @ApiOperation("删除 系统字典表")
    public AjaxResult delete(@Valid @NotNull @PathVariable("id") Long id) {
        dictService.delete(id);
        return AjaxResult.success();
    }

    /**
     * @param id - 需要更新数据的Id
     * @param vO - 更新的数据
     * @return 结果集
     */
    @PutMapping("/{id}")
    @ApiOperation("更新 系统字典表")
    public AjaxResult update(@Valid @NotNull @PathVariable("id") Long id,
                       @Valid @RequestBody DictVO vO) {
        dictService.update(id, vO);
        return AjaxResult.success();
    }

    /**
     * 根据ID获取 系统字典表
     * @param id 实体ID
     * @return 根据id获取的值
     */
    @GetMapping("/{id}")
    @ApiOperation("根据ID获取 系统字典表")
    public AjaxResult getById(@Valid @NotNull @PathVariable("id") Long id) {
        return AjaxResult.success(dictService.getById(id));
    }

    /**
     * 根据实体查询
     * @param dict 实体类
     * @return 结果集
     */
    @GetMapping
    @ApiOperation("根据实体类查询")
    public AjaxResult query(@Valid Dict dict) {
        Dict query = dictService.query(dict);
        return ObjectUtil.isNotNull(query) ? AjaxResult.success(query) : AjaxResult.error("查询结果为空");
    }

    /**
     * 查询全部的字典 数据结构为list
     * @return 结果集
     */
    @GetMapping("/list")
    @ApiOperation("查询全部字典")
    public AjaxResult queryList(){
        List<Dict> result = dictService.list();
         return ObjectUtil.isNotNull(result) ?
                 AjaxResult.success(result)
                 : AjaxResult.error("查询结果为空");
    }

    /**
     * 根据给定的实体类参数查询
     * @param dict 实体类
     * @return 结果集
     */
    @PostMapping("/list")
    @ApiOperation("根据给定的实体类参数查询")
    public AjaxResult queryList(@RequestBody Dict dict){
        List<Dict> result = dictService.list(dict);
        return ObjectUtil.isNotNull(result) ?
                AjaxResult.success(result)
                : AjaxResult.error("查询结果为空");
    }

    /**
     * 根据参数进行分页查询
     * @param dict 字典实体类
     * @param current 当前页数
     * @param size 分页大小
     * @return 结果集
     */
    @PostMapping("/list/{current}/{size}")
    @ApiOperation("分页查询全部字典集")
    public AjaxResult DictPageable(@PathVariable("current") Long current,
                                   @PathVariable("size") Long size,
                                    Dict dict){
        IPage<Dict> iPage = dictService.list(dict, current,size);
        log.info(iPage.toString());
        return ObjectUtil.isNotNull(iPage) ?
                AjaxResult.success("查询成功",iPage)
                : AjaxResult.error("查询结果为空");

    }

    /**
     * 数据类型 分页查询
     * @param type 数据类型
     * @param current 当前页
     * @param size 分页大小
     * @return 结果集
     */
    @GetMapping("/type/{type}/{current}/{size}")
    @ApiOperation("数据类型 分页查询")
    public AjaxResult typePageable(@Valid @NotNull @PathVariable("type")String type,
                           @PathVariable("current") Long current,
                           @PathVariable("size") Long size){
        IPage<Dict> iPage = dictService.queryByType(type, current, size);
        log.info(iPage.toString());
        return ObjectUtil.isNotNull(iPage)?
                AjaxResult.success("查询成功",iPage)
                : AjaxResult.error("查询结果为空");

    }

    /**
     * @param column 列
     * @param val 需要模糊查询的值
     * @return 结果集
     */
    @GetMapping("/{column}/{val}")
    @ApiOperation("模糊查询")
    public AjaxResult queryLike(@PathVariable @NotNull String column, @PathVariable @NotNull String val) {
        List<Dict> res = dictService.like(column,val);
        return ObjectUtil.isNotNull(res) ?
                AjaxResult.success(res) :
                AjaxResult.error("查询结果为空");
    }

    /**
     * 批量插入
     * @param dictList 批量插入的数据 类型是list集合
     * @return AjaxResult
     */
    @PostMapping("/batch")
    @ApiOperation("批量插入")
    public AjaxResult batchSave(@RequestBody ArrayList<Dict> dictList){
        dictService.saveBatch(dictList);
        return  AjaxResult.success("没有问题!");
    }

    /**
     * 根据id批量删除
     * @param ids 主键
     * @return 结果集
     */
    @DeleteMapping("/batch")
    @ApiOperation("根据id批量删除数据")
    public AjaxResult batchDelete(@RequestBody ArrayList<Long> ids){
        boolean res = dictService.deleteBatch(ids);
        return res? AjaxResult.success("没有问题!") : AjaxResult.error("查询结果为空");
    }

    /**
     * 根据外键id查询数据
     * @param foreignKey 外键id
     * @return 请求体
     */
    @GetMapping("/foreign/{foreignKey}")
    @ApiOperation("根据Dic表外键id查询")
    public AjaxResult queryByForeignKey(@PathVariable Integer foreignKey){
        List<Dict> dict = dictService.queryByForeignKey(foreignKey);
        return ObjectUtil.isNotNull(dict)? AjaxResult.success(dict) : AjaxResult.error("查询结果为空");
    }
}
